#include <iostream>
template<typename T>
class unique_ptr {
private:
    T* ptr; // 原生指针，用于持有资源

public:
    // 构造函数：接受一个原生指针，用于初始化智能指针
    explicit unique_ptr(T* p = nullptr) : ptr(p) {}

    // 析构函数：负责释放智能指针所管理的资源
    ~unique_ptr() {
        delete ptr;
    }

    // 移动构造函数：实现资源所有权的转移
    unique_ptr(unique_ptr&& u) noexcept : ptr(u.ptr) {
        u.ptr = nullptr; // 转移后将源对象的指针置空，确保资源不被重复释放
    }

    // 移动赋值操作符：实现资源所有权的转移
    unique_ptr& operator=(unique_ptr&& u) noexcept {
        if (this != &u) { // 自我赋值检查
            delete ptr; // 释放当前对象所管理的资源
            ptr = u.ptr; // 转移资源所有权
            u.ptr = nullptr; // 置空源对象的指针，避免重复释放
        }
        return *this;
    }

    // 删除复制构造函数和复制赋值操作符，防止资源的不当复制
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;

    // 提供访问资源的方法
    T* get() const { return ptr; }
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }

    // 释放资源的控制权，并返回原生指针
    T* release() {
        T* temp = ptr;
        ptr = nullptr;
        return temp;
    }

    // 替换管理的资源
    void reset(T* p = nullptr) {
        T* old = ptr;
        ptr = p;
        delete old; // 释放旧资源
    }

    // 判断智能指针是否为空
    bool is_null() const { return ptr != nullptr; }
};

int main() {
    unique_ptr<int> up1(new int(42));
    std::cout << "up1 points to: " << *up1 << '\n';

    unique_ptr<int> up2 = std::move(up1);
    std::cout << "up2 points to: " << *up2 << '\n';

    up2.reset(new int(100));
    std::cout << "up2 now points to: " << *up2 << '\n';

    return 0;
}